Java多线程：锁的底层实现

最新推荐文章于 2024-03-13 20:58:53 发布

VIP文章奔奔尚

最新推荐文章于 2024-03-13 20:58:53 发布

阅读量4.5k

点赞数 4

分类专栏：编程语言：Java 虚拟机：JVM Java多线程文章标签： Java Jvm

本文链接：https://blog.csdn.net/qq_29753285/article/details/81299509

版权

最近准备招聘，在网上搜集了很多关于JVM获取的锁流程的文章，基本上所有关于偏向锁获取的部分都是错的，所以专门花时间自己看了看代码，整理出来供大家参考。

本文章是Java多线程系列的一篇文章，其他文章：
Java多线程：锁的底层实现
 Java多线程：synchronized和volatile
Java多线程：JUC包-锁的封装
 Java多线程：Thread的使用，以及wait(),notify(),notifyAll()
Java多线程：线程池

一、基本概念

CAS(compare and swap)

参考资料：
https://blog.csdn.net/ls5718/article/details/52563959
缓存一致性协议

1. 什么是CAS

为了提高性能，JVM很多操作都依赖CAS实现，一种乐观锁的实现。本文锁优化中大量用到了CAS，故有必要先分析一下CAS的实现。

CAS：Compare and Swap。如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值。否则，处理器不做任何操作。无论哪种情况，它都会在 CAS 指令之前返回该位置的值。

JNI来完成CPU指令的操作：

openjdk\hotspot\src\os_cpu\windows_x86\vm\atomic_windows_x86.inline.hpp

//这里只粘贴了windowsx86的一个实现
//即：若dest和compare_value的值相同，就将dest的值替换为exchange_value
inline intptr_t Atomic::cmpxchg_ptr(intptr_t exchange_value, volatile intptr_t* dest, intptr_t compare_value) {
  return (intptr_t)cmpxchg((jlong)exchange_value, (volatile jlong*)dest, (jlong)compare_value);
}

inline jlong    Atomic::cmpxchg    (jlong    exchange_value, volatile jlong*    dest, jlong    compare_value) {
  int mp = os::is_MP();//返回是否为多处理器
  jint ex_lo  = (jint)exchange_value;
  jint ex_hi  = *( ((jint*)&exchange_value) + 1 );
  jint cmp_lo = (jint)compare_value;
  jint cmp_hi = *( ((jint*)&compare_value) + 1 );
  __asm {
    push ebx
    push edi
    mov eax, cmp_lo
    mov edx, cmp_hi
    mov edi, dest
    mov ebx, ex_lo
    mov ecx, ex_hi
    LOCK_IF_MP(mp) //会根据当前处理器的类型来决定是否为cmpxchg指令添加lock前缀。如果程序是在多处理器上运行，就为cmpxchg指令加上lock前缀（lock cmpxchg）。反之，如果程序是在单处理器上运行，就省略lock前缀（单处理器自身会维护单处理器内的顺序一致性，不需要lock前缀提供的内存屏障效果）。
    cmpxchg8b qword ptr [edi]
    pop edi
    pop ebx
  }
}

CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。如果A=V，那么把B赋值给V，返回V；如果A！=V，直接返回V。

2. CAS的目的

利用CPU的CAS指令，同时借助JNI来完成Java的非阻塞算法。其它原子操作都是利用类似的特性完成的。而整个J.U.C都是建立在CAS之上的，因此对于synchronized阻塞算法，J.U.C在性能上有了很大的提升。

3. CAS存在的问题

CAS虽然很高效的解决原子操作，但是CAS仍然存在三大问题。ABA问题，循环时间长开销大和只能保证一个共享变量的原子操作

ABA问题。因为CAS需要在操作值的时候检查下值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它的值没有发生变化，但是实际上却变化了。ABA问题的解决思路就是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加一，那么A－B－A 就会变成1A-2B－3A。

从Java1.5开始JDK的atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法作用是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。

关于ABA问题参考文档: http://blog.hesey.net/2011/09/resolve-aba-by-atomicstampedreference.html

循环时间长开销大。自旋CAS如果长时间不成功，会给CPU带来非常大的执行开销。如果JVM能支持处理器提供的pause指令那么效率会有一定的提升，pause指令有两个作用，第一它可以延迟流水线执行指令（de-pipeline）,使CPU不会消耗过多的执行资源，延迟的时间取决于具体实现的版本，在一些处理器上延迟时间是零。第二它可以避免在退出循环的时候因内存顺序冲突（memory order violation）而引起CPU流水线被清空（CPU pipeline flush），从而提高CPU的执行效率。
只能保证一个共享变量的原子操作。当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁，或者有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操作。比如有两个共享变量i＝2,j=a，合并一下ij=2a，然后用CAS来操作ij。从Java1.5开始JDK提供了AtomicReference类来保证引用对象之间的原子性，你可以把多个变量放在一个对象里来进行CAS操作。

安全点(safe point)

http://calvin1978.blogcn.com/articles/safepoint.html

GC时的Stop the World(STW)是大家最大的敌人。但可能很多人没留意，除了GC，JVM底下还会发生这样那样的停顿。

JVM里有一条特殊的线程－－VM Threads，专门用来执行一些特殊的VM Operation，比如分派GC的STW，thread dump等，这些任务，都需要整个Heap，以及所有线程的状态是静止的，一致的才能进行。所以JVM引入了安全点(Safe Point)的概念，想办法在需要进行VM Operation时，通知所有的线程进入一个静止的安全点。如何做到的见聊聊JVM（九）理解进入safepoint时如何让Java线程全部阻塞

除了GC，其他触发安全点的VM Operation包括：

1. JIT相关，比如Code deoptimization, Flushing code cache
2. Class redefinition (e.g. javaagent，AOP代码植入的产生的instrumentation)
3. Biased lock revocation 取消偏向锁
4. Various debug operation (e.g. thread dump or deadlock check)

打开JDK7源码的vm_operations.hpp，有一个长长的列表，比如ReportJavaOutOfMemory等等不能尽录。

Java中的Monitor

参考：
java线程同步原理
 Monitors – The Basic Idea of Java Synchronization => 译文：监视器–JAVA同步基本概念

java会为每个object对象分配一个monitor，当某个对象的同步方法（synchronized methods ）被多个线程调用时，该对象的monitor将负责处理这些访问的并发独占要求。
当一个线程调用一个对象的同步方法时，JVM会检查该对象的monitor。如果monitor没有被占用，那么这个线程就得到了monitor的占有权，可以继续执行该对象的同步方法；如果monitor被其他线程所占用，那么该线程将被挂起，直到monitor被释放。
当线程退出同步方法调用时，该线程会释放monitor，这将允许其他等待的线程获得monitor以使对同步方法的调用执行下去。
注意：Java对象的monitor机制和传统的临界检查代码区技术不一样。java的一个同步方法并不意味着同时只有一个线程独占执行，但临界检查代码区技术确实会保证同步方法在一个时刻只被一个线程独占执行。Java的monitor机制的准确含义是：任何时刻，对一个指定object对象的某同步方法只能由一个线程来调用。
java对象的monitor是跟随object实例来使用的，而不是跟随程序代码。两个线程可以同时执行相同的同步方法，比如：一个类的同步方法是xMethod()，有a,b两个对象实例，一个线程执行a.xMethod()，另一个线程执行b.xMethod(). 互不冲突。

二、基础数据结构

markword

32位虚拟机markword

oopDesc

openjdk\hotspot\src\share\vm\oops\oop.hpp => oopDesc

class oopDesc {
  friend class VMStructs;
 private:
  volatile markOop  _mark;//markOop:Mark Word标记字段
  union _metadata {
    Klass*      _klass;//对象类型元数据的指针
    narrowKlass _compressed_klass;
  } _metadata;

  // Fast access to barrier set.  Must be initialized.
  static BarrierSet* _bs;
  //以下省略
  //...
}

锁状态mask

openjdk\hotspot\src\share\vm\oops\markOop.hpp => markOopDesc

  enum { 
         locked_value             = 0,//00偏向锁 
         unlocked_value           = 1,//01无锁
         monitor_value            = 2,//10监视器锁，又叫重量级锁
         marked_value             = 3,//11GC标记
         biased_lock_pattern      = 5//101偏向锁
  };

三、获取锁的流程

1. monitorenter()

synchronized关键字修饰的代码段，在JVM被编译为monitorenter、monitorexit指令来获取和释放互斥锁.。

解释器执行monitorenter时会进入到InterpreterRuntime.cpp的InterpreterRuntime::monitorenter函数，具体实现如下：

openjdk/hotspot/src/share/vm/interpreter/interpreterRuntime.cpp => monitor_enter()

//------------------------------------------------------------------------------------------------------------------------
// Synchronization
//
// The interpreter's synchronization code is factored out so that it can
// be shared by method invocation and synchronized blocks.
//%note synchronization_3

//%note monitor_1
IRT_ENTRY_NO_ASYNC(void, InterpreterRuntime::monitorenter(JavaThread* thread, BasicObjectLock* elem))
#ifdef ASSERT
  thread->last_frame().interpreter_frame_verify_monitor(elem);
#endif
  if (PrintBiasedLockingStatistics) {
    Atomic::inc(BiasedLocking::slow_path_entry_count_addr());
  }
  Handle h_obj(thread, elem->obj());
  assert(Universe::heap()->is_in_reserved_or_null(h_obj()),
         "must be NULL or an object");
  if (UseBiasedLocking) {
  //如果开启了偏向锁，则直接使用fast_enter()
    // Retry fast entry if bias is revoked to avoid unnecessary inflation
    ObjectSynchronizer::fast_enter(h_obj, elem->lock(), true, CHECK);
  } else {
  //否则使用slow_enter()
    ObjectSynchronizer::slow_enter(h_obj, elem->lock(), CHECK);
  }
  assert(Universe::heap()->is_in_reserved_or_null(elem->obj()),
         "must be NULL or an object");
#ifdef ASSERT
  thread->last_frame().interpreter_frame_verify_monitor(elem);
#endif
IRT_END

总的来说，就是：如果开启了偏向锁，则直接进入fast_enter()方法，否则进入slow_enter()方法

2. 尝试获取偏向锁：fast_enter()

openjdk/hotspot/src/share/vm/interpreter/synchronizer.cpp => ObjectSynchronizer::fast_enter()

// -----------------------------------------------------------------------------
//  Fast Monitor Enter/Exit
// This the fast monitor enter. The interpreter and compiler use
// some assembly copies of this code. Make sure update those code
// if the following function is changed. The implementation is
// extremely sensitive to race condition. Be careful.

void ObjectSynchronizer::fast_enter(Handle obj, BasicLock* lock, bool attempt_rebias, TRAPS) {
 if (UseBiasedLocking) {
  //如果开启了偏向锁
    if (!SafepointSynchronize::is_at_safepoint()) {
  //如果不在安全点
      BiasedLocking::Condition cond = BiasedLocking::revoke_and_rebias(obj, attempt_rebias, THREAD);
      if (cond == BiasedLocking::BIAS_REVOKED_AND_REBIASED) {
  //如果调用结果为BIAS_REVOKED_AND_REBIASED
        return;
      }
    } else {
  //当前处于安全点，调用revoke_at_safepoint
      assert(!attempt_rebias, "can not rebias toward VM thread");
      BiasedLocking::revoke_at_safepoint(obj);
    }
    assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
 }

 slow_enter (obj, lock, THREAD) ;//如果未开启偏向锁，或竞争偏向锁失败
}

这段代码很短，就不作太多解释

2.1 revoke_and_rebias

openjdk/hotspot/src/share/vm/runtime/biasedLocking.cpp => revoke_and_rebias()

/**
* @param obj: 要执行操作的对象
* @param attempt_rebias: 尝试将该对象偏向到当前线程
* @param TRAPS: 
*/
BiasedLocking

最低0.47元/天解锁文章

奔奔尚

关注

4
点赞
踩
23

收藏

觉得还不错? 一键收藏
2
评论
Java多线程：锁的底层实现

最近准备招聘，在网上搜集了很多关于JVM获取的锁流程的文章，基本上所有关于偏向锁获取的部分都是错的，所以专门花时间自己看了看代码，整理出来供大家参考。一、基本概念CAS(compare and swap) 参考资料： https://blog.csdn.net/ls5718/article/details/52563959 缓存一致性协议1. 什么是...
复制链接

扫一扫